// use std::error::Error;
// use std::fmt::format;
// use lazy_static::lazy_static;
// use crate::lincni::convertion::ResultInterface;
// use crate::lincni::error::Errors;
// use std::sync::Arc;
// use std::sync::Mutex;
//
//
//
// #[derive(Clone,Default,Debug)]
// pub struct Converters {
//     inner:Vec<Converter>
// }
//
// impl Converters {
//     pub fn register_converter(&mut self,from:String,to:Vec<String>,f:ConvertFn) {
//         for i in to {
//             if let Some(_) = self.find_converter(from.as_str(),i.as_str()) {
//                 panic!("converter already registered for {} to {}", from, i)
//             }
//         }
//
//         let c = Converter {
//             from_version: from,
//             to_versions: to,
//             convert_fn: f
//         };
//         self.inner.push(c);
//     }
//
//     pub fn convert(&self, from:Box<dyn ResultInterface>, mut to_version:String) -> Result<Box<dyn ResultInterface>,Box<dyn Error>> {
//         if to_version == "" {
//             to_version = "0.1.0".to_string();
//         }
//
//         let from_version = from.version();
//         if from_version == to_version {
//             return Ok(from);
//         }
//
//         let c = self.find_converter(from_version.as_str(),to_version.as_str());
//         if let None = c {
//             return Err(Errors::FromStr(format!("no converter for CNI result version {} to {}", from_version, to_version)).to_dyn());
//         }
//         return match c {
//             None => {Err(Errors::FromStr(format!("no converter for CNI result version {} to {}", from_version, to_version)).to_dyn())}
//             Some(cc) => {
//                 let f = cc.convert_fn;
//                 return f(from,to_version);
//             }
//         }
//     }
//
//     fn find_converter(&self,from_version:&str,to_version:&str) -> Option<&Converter> {
//         for i in self.inner.iter() {
//             if i.from_version.as_str() == from_version {
//                 for v in i.to_versions.iter() {
//                     if v.as_str() == to_version {
//                         return Some(i);
//                     }
//                 }
//             }
//         }
//
//         None
//     }
// }
//
// pub type ConvertFn = fn(result: Box<dyn ResultInterface>,to_version:String) -> Result<Box<dyn ResultInterface>, Box<dyn Error>>;
//
// #[derive(Clone,Debug)]
// struct Converter {
//     from_version:String,
//     to_versions:Vec<String>,
//     convert_fn:ConvertFn,
// }
//
//
